package com.yun.datastructure.linear.list.arraylist;


import java.util.Iterator;
import java.util.function.Consumer;

public class MyArrayList implements Iterable<Integer> {

    /**
     * 底层存储数据的数组
     * 一开始不进行赋值,这样创建该类时,也不会创建底层的数组
     * 等进行添加等操作时,使用扩容方法进行检查后再创建
     */
    private int[] array = {};
    private int capacity;
    private int size;

    public MyArrayList() {
        this.capacity = 10;
        this.size = 0;
    }

    //检查数组和扩容
    public void checkAndGrow() {
        //容量检查
        if (size == 0) {//如果还没创建数组则创建一个容量为初始容量的数组
            array = new int[capacity];
        } else if (size == capacity) {//此时数组容量已满,需要进行扩容
            //默认扩容1.5倍
            capacity += capacity >> 1;
            //创建一个新容量的数组,将原来数组的数据复制过去
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }
        //else 不做出任何行为
    }

    //越界检查
    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException("索引越界" + index);
        }
    }

    //添加越界检查
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("索引越界" + index);
        }
    }

    //在指定位置添加元素
    public void add(int index, int element) {
        rangeCheckForAdd(index);
        checkAndGrow();
        System.arraycopy(array, index, array, index + 1, size - index);
        array[index] = element;
        size++;
    }

    //在最后位置添加元素
    public void add(int element) {
        add(size, element);
    }

    //删除指定位置的元素
    public int remove(int index) {
        rangeCheck(index);
        int removed = array[index];
        System.arraycopy(array, index + 1, array, index, size - index - 1);
        size--;
        return removed;


    }

    //修改指定位置的元素
    public boolean set(int index, int element) {
        rangeCheck(index);
        array[index] = element;
        return true;
    }

    //获取指定位置的元素
    public int get(int index) {
        rangeCheck(index);
        return array[index];
    }

    // 返回当前数组大小
    public int size() {
        return size;
    }

    // 清空数组
    public void clear() {
        array = new int[capacity];
        size = 0;
    }

    //判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }


    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int p = 0;

            @Override
            public boolean hasNext() {
                return p < size;
            }

            @Override
            public Integer next() {
                return array[p++];
            }

            @Override
            public void remove() {
                if (p < 0) {
                    throw new IllegalStateException("非法状态");
                }
                MyArrayList.this.remove(--p);
            }
        };
    }

    /**
     * 实现foreach方法
     * foreach方法实际上依赖于iterator方法
     *
     * @param action
     */
    @Override
    public void forEach(Consumer<? super Integer> action) {
        //使用iterator方法获取迭代器
        for (Integer integer : this) {
            action.accept(integer);
        }
    }
}
